# -*- coding: utf-8 -*-

#    Copyright (C) 2005-2012 by Promotux
#                        di Francesco Meloni snc - http://www.promotux.it/

#    Author: Francesco Meloni  <francesco@promotux.it>

#    This file is part of Promogest.

#    Promogest is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 2 of the License, or
#    (at your option) any later version.

#    Promogest is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.

#    You should have received a copy of the GNU General Public License
#    along with Promogest.  If not, see <http://www.gnu.org/licenses/>.

import random
import datetime
from decimal import *
from promogest.lib.page import Page
from promogest.dao.Cliente import Cliente, getNuovoCodiceCliente
from promogest.dao.ClienteCategoriaCliente import ClienteCategoriaCliente
from promogest.modules.Contatti.dao.ContattoCliente import ContattoCliente
from promogest.modules.Contatti.dao.RecapitoContatto import RecapitoContatto
from promogest.modules.Contatti.dao.Contatto import Contatto
from promogest.dao.PersonaGiuridica import PersonaGiuridica_ as PersonaGiuridica
from promogest.dao.Pagamento import Pagamento
from promogest.dao.Banca import Banca
from promogest.dao.Listino import Listino
from promogest.dao.Magazzino import Magazzino
from promogest.dao.CategoriaCliente import CategoriaCliente
from promogest.lib.webutils import *
from promogest.ui.utils import *
from promogest.pages.modules.infopesoWeb import infopesoWeb
from promogest.dao.PersonaGiuridica import PersonaGiuridica_ as PersonaGiuridica
from promogest.dao.PersonaGiuridicaPersonaGiuridica import PersonaGiuridicaPersonaGiuridica
from promogest.dao.Setconf import SetConf
from promogest.modules.InfoPeso.dao.TestataInfoPeso import TestataInfoPeso
from promogest.modules.InfoPeso.dao.ClienteGeneralita import ClienteGeneralita
from promogest.modules.InfoPeso.dao.TipoTrattamento import TipoTrattamento
from promogest.modules.InfoPeso.dao.RigaInfoPeso import RigaInfoPeso


COOKIENAME = SetConf().select(key="cookie_name")[0].value

import ConfigParser


def salvaAttivita(req):
    """ Funzione che salva l'attività nel file di sessione
    o aggiorna l'esistente"""
    config = ConfigParser.RawConfigParser()
    attivita = req.form.get("attivita")
    sid = req.cookies[COOKIENAME]
    session_file = Environment.session_dir + "/" + sid
    #config.add_section('Main')
    config.read(session_file)
    if attivita is not None:
        config.set('Main', 'id_attivita', attivita)
    try:
        attivita = config.get('Main', 'id_attivita')
    except:
        try:
            config.set('Main', 'id_attivita', None)
        except:
            return Page(req).redirect("/")
    with open(session_file, 'wb') as configfile:
        config.write(configfile)
    return attivita


def readAttivita(req):
    config = ConfigParser.RawConfigParser()
    sid = req.cookies[COOKIENAME]
    session_file = Environment.session_dir + "/" + sid
    config.read(session_file)
    try:
        id_attivita = config.get('Main', 'id_attivita')
    except:
        return Page(req).redirect("/")
    return id_attivita


def anagraficaCliente(req, action=None, quarto=None):
    """
    Funzione di gestione delle preview
    """

    def sort_by_attr(seq, attr):
        intermed = [(getattr(seq[i], attr).upper() , i, seq[i]) for i in xrange(len(seq))]
        intermed.sort()
        return [tup[-1] for tup in intermed]

    def _list_(req, action=None):
        """ """
        daos = []
        daos2 = []
        id = req.args.get("idr")
        attivita = salvaAttivita(req)
        if attivita is not None:
            attivita = readAttivita(req)
        if not attivita:
            return Page(req).redirect("/")
        fk_ragione_sociale = None
        fk_insegna = None
        fk_cognome_e_nome = None
        fk_codice=None
        fk_localita = None
        fk_codice_fiscale = None
        fk_partita_iva = None
        fk_id_categoria_cliente = None
        if req.form.to_dict():
            fk_ragione_sociale = req.form.get("ragione_sociale")
            fk_insegna = req.form.get("insegna")
            fk_cognome_e_nome = req.form.get("cognome_e_nome")
            fk_codice = req.form.get("codice")
            fk_localita = req.form.get("localita")
            fk_codice_fiscale = req.form.get("codice_fiscale")
            fk_partita_iva = req.form.get("partita_iva")
            fk_id_categoria_cliente = req.form.get("id_categoria_cliente")
        elif req.args.get("searchkey"):
            dicio = eval(req.args.get("searchkey"))
            fk_ragione_sociale = dicio["ragione_sociale"]
            fk_insegna = dicio["insegna"]
            fk_cognome_e_nome = dicio["cognome_e_nome"]
            fk_codice = dicio["codice"]
            fk_localita = dicio["localita"]
            fk_codice_fiscale = dicio["codice_fiscale"]
            fk_partita_iva = dicio["partita_iva"]
            fk_id_categoria_cliente = dicio["id_categoria_cliente"]

        if attivita != "0" and attivita is not None:
            #pgg = PersonaGiuridicaPersonaGiuridica()\
                #.select(idPersonaGiuridica=int(attivita), batchSize=None)
            pgg = Environment.session\
                    .query(PersonaGiuridicaPersonaGiuridica.id_persona_giuridica_abbinata)\
                    .filter(PersonaGiuridicaPersonaGiuridica.id_persona_giuridica==int(attivita))\
                    .all()
            #TODO ATTENZIONE: QUI VENGONO PRESI ANCHE GLI ABBINAMENTI ATTIVITÀ CHE IL SISTEMA NON RICONOSCE DIVERSI DA CLIENTI RIVEDERE QUANTO PRIMA
            #for d in pgg:
                #print "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD", d
            pglist = [a[0] for a in pgg]
            cli = Cliente().select(id=pglist,
                                ragioneSociale=fk_ragione_sociale,
                                localita = fk_localita,
                                codiceFiscale = fk_codice_fiscale,
                                batchSize=40)
#            idcli = [(c.id,) for c in cli]
            for i in cli:
                if (i.id,) in pgg:
                    daos2.append(i)
                    daos = sort_by_attr(daos2,"ragione_sociale")

        chiavi = {
                    "ragione_sociale" : fk_ragione_sociale,
                    "cognome_e_nome" : fk_cognome_e_nome,
                    "localita" : fk_localita,
                    "codice_fiscale": fk_codice_fiscale,

                        }
        batch = 20
        count = Cliente(req=req).count(ragioneSociale=fk_ragione_sociale,
                                        insegna=fk_insegna,
                                        cognomeNome=fk_cognome_e_nome,
                                        codice = fk_codice,
                                        localita = fk_localita,
                                        codiceFiscale = fk_codice_fiscale,
                                        partitaIva = fk_partita_iva,
                                        idCategoria = fk_id_categoria_cliente,
                                        )
        args = pagination(req,batch,count)
        args["page_list"] = "anagrafiche/cliente/list"
        if not daos and getRoleFromId(req)=="Admin":
            daos = Cliente(req=req).select( ragioneSociale=fk_ragione_sociale,
                                            cognomeNome=fk_cognome_e_nome,
                                            localita = fk_localita,
                                            codiceFiscale = fk_codice_fiscale,
                                            batchSize=batch,
                                            offset=args["offset"])
#        categorie = CategoriaCliente().select(batchSize=None)
        if id:
            daos = [Cliente().getRecord(id=int(id))]
        pageData = {'file': "anagraficaComplessa",
                    "_dao_": "cliente",
                    "name": "Cliente",
                    "tree": "treeCliente",
                    "fkey": "fk_cliente",
#                    "categorie": categorie,
                    "chiavi": chiavi,
                    "action": action,
                    "daos": daos,
                    "count": count,
                    "args": args,
                    "show_spalla": True,
                    "attivita": attivita}
        return Page(req).render(pageData)

    def __add__(req, action=None, dgi=None):
        """ TODO: Gestione dei campi obbligatori e delle chiavi duplicate"""
        id = req.form.get("id")
        if action == "add":
            dao = Cliente()
        else:
            dao = Cliente().getRecord(id=id)

        #codice = req.form.get("codice")
        if not dao.codice:
            dao.codice = getNuovoCodiceCliente()
        dao_contatto = None
        if dao.id:
            dao_contatto = ContattoCliente().select(idCliente=dao.id)
            if dao_contatto:
                dao_contatto = dao_contatto[0]
            else:
                dao_contatto = ContattoCliente()
        else:
            dao_contatto = ContattoCliente()

        if req.form.get("id_pagamento"):
            dao.id_pagamento = int(req.form.get("id_pagamento"))
        if req.form.get("id_magazzino"):
            dao.id_magazzino = int(req.form.get("id_magazzino"))
        if req.form.get("id_listino"):
            dao.id_listino = int(req.form.get("id_listino"))
        if req.form.get("id_banca"):
            dao.id_banca = int(req.form.get("id_banca"))
        # parte di tabella su persona giuridica
        dao.ragione_sociale = req.form.get("cognome") +" "+req.form.get("nome")
        dao.insegna = req.form.get("insegna")
        dao.cognome = req.form.get("cognome")
        dao.nome = req.form.get("nome")
        dao.tipo = "PF"
        dao.pagante = False
        dao.sede_operativa_indirizzo = req.form.get("sede_operativa_indirizzo")
        dao.sede_operativa_cap = req.form.get("sede_operativa_cap")
        dao.sede_operativa_provincia = req.form.get("sede_operativa_provincia")
        dao.sede_operativa_localita = req.form.get("sede_operativa_localita")
        dao.sede_legale_indirizzo = req.form.get("sede_legale_indirizzo")
        dao.sede_legale_cap = req.form.get("sede_legale_cap")
        dao.sede_legale_provincia = req.form.get("sede_legale_provincia")
        dao.sede_legale_localita = req.form.get("sede_legale_localita")
        #nazione    character varying(100)
        dao.codice_fiscale= req.form.get("codice_fiscale")
        dao.partita_iva = req.form.get("partita_iva")
        dao.note = req.form.get("cliente_note")
        id_attivita = None
        if req.cookies.has_key(COOKIENAME):
            filee = req.cookies[COOKIENAME]
            session_file = Environment.session_dir + "/" + filee
            if os.path.exists(session_file):
                s_file = open(session_file, 'r')
                try:
                    for a in s_file.readlines():
                        if "id_attivita" in a:
                            id_attivita = int(a.split("=")[1])
                        s_file.close()
                except:
                    pass

        if not dao.id_user:
            user = User()
            username = req.form.get("nome").strip()\
                .replace(" ", "").lower()[0]\
                + "." + req.form.get("cognome").strip()\
                .replace(" ", "").lower()
            user.username = username
            user.password = "giustopeso" + str(random.randrange(0, 101, 2))
            user.email = req.form.get("cliente_email_principale")\
                or "cambiare@cambiare.com"
            user.id_role = 7
            user.active = True
            user.tipo_user = "PLAIN"
            user.email_confirmed = req.form.get("email_confirmed") or False
            user.persist()
            dao.id_user = user.id
            #tipo_user character varying(50),
        else:
            user = User().getRecord(id=dao.id_user)
            if user:
                user.password = req.form.get("password")
                user.tipo_user = "PLAIN"
                user.id_role = 7
                user.active = True
                user.email_confirmed = req.form.get("email_confirmed") or False
                user.persist()
        if dao.codice:
            dao.persist()

        dao_generalita_infopeso = ClienteGeneralita().select(idCliente=dao.id)
        if dao_generalita_infopeso:
            dao_generalita_infopeso = dao_generalita_infopeso[0]
        else:
            dao_generalita_infopeso = ClienteGeneralita()
            #dao_generalita_infopeso.id_cliente = dao.id
            #dao_generalita_infopeso.persist()

        dao_testata_infopeso = TestataInfoPeso().select(idCliente=dao.id)
        if dao_testata_infopeso:
            dao_testata_infopeso = dao_testata_infopeso[0]
        else:
            dao_testata_infopeso = TestataInfoPeso()
            #dao_testata_infopeso.id_cliente = dao.id
            #dao_testata_infopeso.persist()

        dao_testata_infopeso.data_inizio= datetime.datetime.now()
        dao_testata_infopeso.data_fine = datetime.datetime.now()
        if req.form.get("privacy") == "1":
            dao_testata_infopeso.privacy = True
        else:
            dao_testata_infopeso.privacy = False
        #dao_testata_infopeso.privacy = req.form.get("privacy")
        dao_testata_infopeso.note = req.form.get("note") or ""
        dao_testata_infopeso.citta = req.form.get("citta")
        dao_testata_infopeso.id_cliente = dao.id
        dao_testata_infopeso.persist()

        dao_generalita_infopeso.data_nascita = stringToDate(req.form.get("data_nascita"))
        dao_generalita_infopeso.altezza = req.form.get("altezza")
        dao_generalita_infopeso.genere = req.form.get("genere")
        dao_generalita_infopeso.id_cliente = dao.id
        dao_generalita_infopeso.persist()




        if id_attivita:
            pggg = PersonaGiuridicaPersonaGiuridica()\
                .select(idPersonaGiuridica= id_attivita,
                        idPersonaGiuridicaAbbinata=dao.id)
            if pggg:
                pgg = pggg[0]
            else:
                pgg = PersonaGiuridicaPersonaGiuridica()
            pgg.id_persona_giuridica = id_attivita
            pgg.id_persona_giuridica_abbinata = dao.id
            pgg.persist()

        #SEzione dedicata ai contatti/recapiti principali
        if Environment.tipo_eng =="sqlite" and not dao_contatto.id:
            forMaxId = Contatto().select(batchSize=None)
            if not forMaxId:
                dao_contatto.id = 1
            else:
                idss = []
                for l in forMaxId:
                    idss.append(l.id)
                dao_contatto.id = (max(idss)) +1
        appa = ""
        if dao.ragione_sociale:
            appa = appa +" "+dao.ragione_sociale
        if dao.cognome:
            appa = appa+" " +dao.cognome
        dao_contatto.cognome = appa
        if dao.nome:
            dao_contatto.nome = dao.nome
        dao_contatto.tipo_contatto ="cliente"
        dao_contatto.id_cliente = dao.id
        dao_contatto.persist()

        recont = RecapitoContatto().select(idContatto = dao_contatto.id,
            tipoRecapito="Cellulare")
        if recont:
            reco = recont[0]
            if req.form.get("cliente_cellulare_principale") == "" or reco.recapito=="":
                reco.delete()
            else:
                reco.id_contatto = dao_contatto.id
                reco.tipo_recapito = "Cellulare"
                reco.recapito = req.form.get("cliente_cellulare_principale")
                reco.persist()

        else:
            reco = RecapitoContatto()
            reco.id_contatto = dao_contatto.id
            reco.tipo_recapito = "Cellulare"
            reco.recapito = req.form.get("cliente_cellulare_principale")
            reco.persist()

        recont = RecapitoContatto().select(idContatto = dao_contatto.id,
            tipoRecapito="Telefono")
        if recont:
            reco = recont[0]
            if req.form.get("cliente_telefono_principale") =="" or reco.recapito=="":
                reco.delete()
            else:
                reco.id_contatto = dao_contatto.id
                reco.tipo_recapito = "Telefono"
                reco.recapito = req.form.get("cliente_telefono_principale")
                reco.persist()
        else:
            reco = RecapitoContatto()
            reco.id_contatto = dao_contatto.id
            reco.tipo_recapito = "Telefono"
            reco.recapito = req.form.get("cliente_telefono_principale")
            reco.persist()


        recont = RecapitoContatto().select(idContatto = dao_contatto.id,
            tipoRecapito="Email")
        if recont:
            reco = recont[0]
            if req.form.get("cliente_email_principale") =="" or reco.recapito=="":
                reco.delete()
            else:
                reco.id_contatto = dao_contatto.id
                reco.tipo_recapito = "Email"
                reco.recapito = req.form.get("cliente_email_principale")
                reco.persist()
        else:
            reco = RecapitoContatto()
            reco.id_contatto = dao_contatto.id
            reco.tipo_recapito = "Email"
            reco.recapito = req.form.get("cliente_email_principale")
            reco.persist()

        recontw = RecapitoContatto().select(idContatto = dao_contatto.id,
            tipoRecapito="Sito")
        if recontw:
            recow = recontw[0]
            if req.form.get("cliente_sito_web_principale") == "" or recow.recapito=="":
                recow.delete()
            else:
                recow.id_contatto = dao_contatto.id
                recow.tipo_recapito = "Sito"
                recow.recapito = req.form.get("cliente_sito_web_principale")
                recow.persist()
        else:
            recow = RecapitoContatto()
            recow.id_contatto = dao_contatto.id
            recow.tipo_recapito = "Sito"
            recow.recapito = req.form.get("cliente_sito_web_principale")
            recow.persist()

        recont = RecapitoContatto().select(idContatto = dao_contatto.id,
            tipoRecapito="Fax")
        if recont:
            reco = recont[0]
            if req.form.get("cliente_fax_principale") =="" or reco.recapito=="":
                reco.delete()
            else:
                reco.id_contatto = dao_contatto.id
                reco.tipo_recapito = "Fax"
                reco.recapito = req.form.get("cliente_fax_principale")
                reco.persist()
        else:
            reco = RecapitoContatto()
            reco.id_contatto = dao_contatto.id
            reco.tipo_recapito = "Fax"
            reco.recapito = req.form.get("cliente_fax_principale")
            reco.persist()

        denominazione_altra_destinazione = req.form.get("denominazione_altra_destinazione")
        indirizzo_altra_destinazione = req.form.get("indirizzo_altra_destinazione")
        localita_altra_destinazione = req.form.get("localita_altra_destinazione")
        cap_altra_destinazione = req.form.get("cap_altra_destinazione")
        provincia_altra_destinazione = req.form.get("provincia_altra_destinazione")
        from promogest.dao.DestinazioneMerce import DestinazioneMerce
        if denominazione_altra_destinazione != "" and indirizzo_altra_destinazione != "" and localita_altra_destinazione != "":
            from promogest.dao.DestinazioneMerce import DestinazioneMerce
            dm = DestinazioneMerce()
            dm.id_cliente =  dao.id
            dm.denominazione = denominazione_altra_destinazione
            dm.indirizzo = indirizzo_altra_destinazione
            dm.localita = localita_altra_destinazione
            dm.cap = cap_altra_destinazione
            dm.provincia = provincia_altra_destinazione
            dm.persist()
        else:
            dm = DestinazioneMerce().select(idCliente= dao.id, batchSize=None)
            if dm:
                for d in dm:
                    d.delete


        redirectUrl='/anagrafiche/cliente/list?idr='+str(dao.id)
        return Page(req).redirect(redirectUrl)

    def __del__(req, action=None):
        """ TODO: Gestione delle chiavi non cancellabili """
        id = req.form.get("idr")
        dao = Cliente().getRecord(id=id)
        if dao:
            dao.delete()
        daos = Cliente(req=req).select()
        pageData = {'file' : "/tree/treeCliente",
                    "_dao_":"cliente",
                    "name": "Cliente",
                    "tree":"treeCliente",
                    "action":action,
                    "daos":daos,
                    "daoCliente":daos}
        return Page(req).render(pageData)

    def __edit__(req, action=None, dgi=None, dti=None):
        id = req.form.get("idr")
        pagamenti = Pagamento().select(batchSize=None)
        listini = Listino().select(batchSize=None)
        banche = Banca().select(batchSize=None)
        magazzini = Magazzino().select(batchSize=None)
        categoriecliente = CategoriaCliente().select(batchSize=None)
        dao = Cliente().getRecord(id=int(id))
        if dao.dm:
            dm = dao.dm[0]
        else:
            dm = None
        dao_generalita_infopeso = ClienteGeneralita().select(idCliente=id)
        if dao_generalita_infopeso:
            dao_generalita_infopeso = dao_generalita_infopeso[0]
        else:
            dao_generalita_infopeso = ClienteGeneralita()

        dao_testata_infopeso = TestataInfoPeso().select(idCliente=id)
        if dao_testata_infopeso:
            dao_testata_infopeso = dao_testata_infopeso[0]
        else:
            dao_testata_infopeso = TestataInfoPeso()

        #idscatecli = [a.id_categoria_cliente for a in dao.categorieCliente]
        idscatecli = []

        pageData = {'file' : "/addedit/ae_cliente",
                    "_dao_":"cliente",
                    "editpage" : "editpage",
                    "pagamenti":pagamenti,
                    "listini":listini,
                    "banche": banche,
                    "magazzini":magazzini,
                    "categoriecliente":categoriecliente,
                    "idscatecli":idscatecli,
                    "name": "Cliente",
                    "tree":"treeCliente",
                    "action":action,
                    "dao":dao,
                    "dm":dm,
                    "daoCliente": dao,
                    "generalita": dao_generalita_infopeso,
                    "testata_infopeso": dao_testata_infopeso,}
        return Page(req).render(pageData)


    def __new__(req, action=None):
        pagamenti = Pagamento().select(batchSize=None)
        listini = Listino().select(batchSize=None)
        banche = Banca().select(batchSize=None)
        magazzini = Magazzino().select(batchSize=None)
        categoriecliente = CategoriaCliente().select(batchSize=None)
        pageData = {'file' : "/addedit/ae_cliente",
                    "_dao_":"cliente",
                    "name": "Cliente",
                    "tree":"treeCliente",
                    "action":action,
                    "pagamenti":pagamenti,
                    "listini":listini,
                    "banche": banche,
                    "magazzini":magazzini,
                    "categoriecliente":categoriecliente,
                    "dao":None,
                    "dm":None,
                    "daoCliente":None,
                    "generalita": None,
                    "testata_infopeso": None,
                    }
        return Page(req).render(pageData)


    def __infopeso__(req, action=None, quarto=None):
        idd = req.form.get("idr")
        dao = Cliente().getRecord(id=idd)
        return infopesoWeb(req,dao=dao, action=action, quarto=quarto)

    if not getUserFromId(req):
        redirectUrl="/"
        return Page(req).redirect(redirectUrl)
    elif action=="list":
        return _list_(req, action=action)
    elif action=="add" or action=="fromedit":
        return __add__(req, action=action)
    elif action=="delete":
        return __del__(req, action=action)
    elif action=="edit":
        return __edit__(req, action=action)
    elif action=="new":
        return __new__(req, action=action)
    elif action and "infopeso".lower() in action.lower():
        return __infopeso__(req, action=action, quarto=quarto)
    else:
        pageData = {'file' : 'not_found'}
        return Page(req).render(pageData)
